🔒 Sicurezza in Python

import bcrypt

# 1. Creare un hash da una password
password = "MiaSuperPassword123!"

# Convertire la stringa in bytes (bcrypt richiede bytes)
password_bytes = password.encode('utf-8')

# Generare il salt e creare l'hash
# Il numero 12 indica il "cost factor" (numero di rounds)
# Più alto = più sicuro ma più lento (valore tipico: 10-14)
hashed = bcrypt.hashpw(password_bytes, bcrypt.gensalt(rounds=12))

print(f"Password originale: {password}")
print(f"Hash generato: {hashed}")
# Output: b'$2b$12$KIXJLqvXhZ...' (sempre diverso ad ogni esecuzione!)

# 2. Verificare una password
# Simuliamo l'input dell'utente al login
input_password = "MiaSuperPassword123!"
input_bytes = input_password.encode('utf-8')

# Verifica se la password corrisponde all'hash
if bcrypt.checkpw(input_bytes, hashed):
    print("✅ Password corretta!")
else:
    print("❌ Password errata!")

# 3. Esempio con password sbagliata
wrong_password = "PasswordSbagliata"
wrong_bytes = wrong_password.encode('utf-8')

if bcrypt.checkpw(wrong_bytes, hashed):
    print("✅ Password corretta!")
else:
    print("❌ Password errata!")  # Questo verrà stampato

from cryptography.fernet import Fernet

class SymmetricEncryption:
    """Gestisce la crittografia simmetrica usando Fernet (AES-128)."""
    
    def __init__(self):
        self.key = None
        self.cipher = None
    
    def generate_key(self):
        """Genera una nuova chiave casuale."""
        self.key = Fernet.generate_key()
        self.cipher = Fernet(self.key)
        return self.key
    
    def encrypt(self, plaintext: str) -> bytes:
        """Cifra un testo."""
        if self.cipher is None:
            raise ValueError("Nessuna chiave caricata")
        return self.cipher.encrypt(plaintext.encode('utf-8'))
    
    def decrypt(self, ciphertext: bytes) -> str:
        """Decifra un testo."""
        if self.cipher is None:
            raise ValueError("Nessuna chiave caricata")
        return self.cipher.decrypt(ciphertext).decode('utf-8')


# Esempio di utilizzo
crypto = SymmetricEncryption()
key = crypto.generate_key()

# Cifrare un messaggio
messaggio = "Questo è un messaggio segreto! 🔒"
cifrato = crypto.encrypt(messaggio)
print(f"Messaggio cifrato: {cifrato}")

# Decifrare il messaggio
decifrato = crypto.decrypt(cifrato)
print(f"Messaggio decifrato: {decifrato}")

# ❌ VULNERABILE - NON FARE MAI QUESTO!
import sqlite3

def login_vulnerable(username, password):
    """Funzione di login VULNERABILE a SQL Injection."""
    conn = sqlite3.connect('users.db')
    cursor = conn.cursor()
    
    # ⚠️ PERICOLOSO: Query costruita con concatenazione di stringhe
    query = f"SELECT * FROM users WHERE username = '{username}' AND password = '{password}'"
    
    cursor.execute(query)
    result = cursor.fetchone()
    conn.close()
    
    return result is not None

# 🔓 ATTACCO SQL INJECTION
username_attacker = "admin' OR '1'='1"
password_attacker = "qualsiasi"

if login_vulnerable(username_attacker, password_attacker):
    print("💀 ATTACCO RIUSCITO! Login senza password!")

# La query diventa:
# SELECT * FROM users WHERE username = 'admin' OR '1'='1' AND password = 'qualsiasi'
# Che è sempre vera perché '1'='1' è sempre vero!

import sqlite3

def login_secure(username, password):
    """Login SICURO usando query parametrizzate."""
    conn = sqlite3.connect('users.db')
    cursor = conn.cursor()
    
    # ✅ SICURO: Usa placeholder (?) invece di concatenazione
    # Il database gestisce automaticamente l'escape dei caratteri speciali
    query = "SELECT * FROM users WHERE username = ?"
    
    cursor.execute(query, (username,))  # Tupla di parametri
    result = cursor.fetchone()
    conn.close()
    
    return result is not None

# Tentativo di SQL Injection (fallisce!)
username_attacker = "admin' OR '1'='1"

if login_secure(username_attacker, "qualsiasi"):
    print("Login riuscito")
else:
    print("✅ Attacco bloccato! SQL Injection non funziona")
    # Username "admin' OR '1'='1" viene trattato come stringa letterale

import re

class InputValidator:
    """Classe per validare vari tipi di input."""
    
    @staticmethod
    def validate_email(email):
        """Valida un indirizzo email."""
        pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
        
        if not email:
            return False, "Email non può essere vuota"
        
        if len(email) > 254:
            return False, "Email troppo lunga"
        
        if not re.match(pattern, email):
            return False, "Formato email non valido"
        
        return True, None
    
    @staticmethod
    def validate_password(password):
        """Valida una password secondo criteri di sicurezza."""
        errors = []
        
        if len(password) < 8:
            errors.append("Password deve essere lunga almeno 8 caratteri")
        
        if not re.search(r'[A-Z]', password):
            errors.append("Password deve contenere almeno una maiuscola")
        
        if not re.search(r'[a-z]', password):
            errors.append("Password deve contenere almeno una minuscola")
        
        if not re.search(r'\d', password):
            errors.append("Password deve contenere almeno un numero")
        
        if not re.search(r'[!@#$%^&*(),.?":{}|<>]', password):
            errors.append("Password deve contenere almeno un carattere speciale")
        
        return len(errors) == 0, errors


# Esempio di utilizzo
validator = InputValidator()

# Test Email
emails = ["user@example.com", "invalid.email", "user@"]

for email in emails:
    is_valid, error = validator.validate_email(email)
    status = "✅" if is_valid else "❌"
    print(f"{status} {email}: {error or 'Valida'}")

# Test Password
passwords = ["Abc123!@", "short", "nouppercase123!"]

for pwd in passwords:
    is_valid, errors = validator.validate_password(pwd)
    status = "✅" if is_valid else "❌"
    print(f"{status} {pwd}")
    if errors:
        for error in errors:
            print(f"   - {error}")